System and method for sending and/or receiving entropy and entropy expansion

ABSTRACT

A message is embedded within an entropy stream. The message is encrypted using a onetime pad (OTP) and thus looks like part of the entropy string since the OTP encrypted messages is, as long as the “pad” material and message content are known, itself random to the observer. The encrypted message contains information used to identify and/or point to relevant information in another part of the entropy stream. For example, the OTP-encrypted message may indicate the number of units of the message, and point to a position in another part of the stream where another message is located. The stream may be randomly and deterministically expanded. Other techniques encrypt a stream using standard encryption, the stream comprising messages that are deterministically OTP encrypted; expand said encryption using a byte vector/array of randomness including at least one random vector; periodically swap out at least one member from the vector; hide vector random bytes in messages and/or using the messages to direct which bytes to remove from the stream of randomness/entropy; and store a stash of randomness separately from the messages and/or pull off the random/entropy stream as directed by the messages. By using true random and determinism, we create a method of generate a known pool of randomness that, if intercepted, cannot be discovered through mathematical analysis.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a divisional of U.S. application Ser. No.16/704,672, filed on Dec. 5, 2019, now U.S. patent Ser. No. ______,which claims priority from U.S. provisional patent application No.62/923,994, filed on Oct. 21, 2019, and U.S. provisional patentapplication No. 62/775,761 filed Dec. 5, 2018. These applications areincorporated herein by reference in their entirety as if expressly setforth.

STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT

None.

FIELD

Example non-limiting technology herein relates to providing entropy to acomputing device for use in encrypting/decrypting and/or performingother processes. Still more particularly, the technology relates totransmitting entropy over a secure and/or insecure communications linkor channel in a way that prevents attackers/eavesdroppers from learninghow to use the entropy. The technology also relates to secure techniquesfor expanding entropy to increase security and conserve networkbandwidth.

BACKGROUND

Entropy refers to the disorder or randomness in the universe. In therealm of technology, entropy is not undesirable. To the contrary, insome forms of computing, entropy is used as a source of purely randomdata for processes that require or benefit from randomness. Suchprocesses may include art, gambling, science, cryptography, and others.As an example, cryptographic functions become more secure if theinformation used to generate them is highly unpredictable and thereforeless likely to be learned or predicted by an attacker. Rather thansimply guessing a password that might include a birthdate or the name ofa pet, an attacker must somehow generate a purely random string that isnot predictable from any other information he has or can obtain.

In the past, truly random numbers were hard to generate. Nowadays, it ispossible to purchase hardware-based, true random or pseudorandom numbergenerators (TRNGs or PRNG's respectively) that generate lengthy stringsof random/pseudorandom data that don't conform to any discerniblepattern. Such TRNG's work based on some kind of natural phenomena thatgenerates random noise (e.g, earth tremors, temperature fluctuations,electrical discharge, deactivation light intensity of a semiconductorlight emitting diode, etc.) or more recently, quantum physics. See e.g.,Garcia-Escartin, “Quantum Random Number Generators” Reviews of ModernPhysics 89, 015004 (2017).

The truly random data such number generators produce can be evaluatedbased upon its “entropy:—a measure of the unpredictability ofinformation content. See, e.g., “A Statistical Test Suite for Random andPseudorandom Number Generators for Cryptographic Applications”,SP800-22REV.1a, NIST Information Technology Laboratory (April 2010).

A potential problem to be solved relates to secure transmission ofrandom information over a communication channel. As one particularexample, the outputs of random and pseudorandom number generators areoften used for the generation of cryptographic key material. Suchcryptographic key material is typically needed as a shared secret onboth sides of an encryption/decryption process. In particular, atransmitter of secure information uses the random data to encrypt amessage, and a receiver for decrypting the information needs the samerandom data (or at least a derivative of it such as in Public Keycrytptography) to decrypt the message. It can be a challenge tocommunicate the random information from one side to the other (or toboth sides in the case of random information generated elsewhere)without the random information being intercepted and used to defeat thesecurity of the encryption/decryption process.

As an example, suppose Mary, Queen of Scots wishes to send secretletters to her nobleman friend Anthony Babington. She could use a simpletransposition cypher in which each letter of the alphabet is mapped intoa symbol, and in which some commonly used words are also mapped directlyinto different symbols. She could share the list of transpositions withMr. Babington when he personally comes to visit her in prison.Unfortunately for Mary, such simple cyphers can be broken through atechnique known as “frequency analysis.” Basically, the characteristicsof the written language (and in particular, the fact that certainletters such as vowels appear more often than certain other letters) canbe used to make educated guesses concerning what the encrypted messagemust be. If many of Mary's letters are intercepted by the governmentcodebreakers, they will use frequency analysis to eventually figure outthe cipher she has been using to communicate with Mr. Babington. Theresult could be disastrous for Mary—for example, public execution.

Now suppose Mary had be able to use a truly random transposition. Bymapping each secret letter against random data and using new random datafor each letter she encrypts, the government codebreakers could not haveguessed through frequency analysis or otherwise what her cipher was, andthe content of her letters would remain unknown even if the lettersthemselves were intercepted by the government. However, to make thiskind of system useful, Mr. Babington would also need to have access tothe same random transposition. If Mr. Babington were unable to visitMary in prison, Mary would need to smuggle the random transposition foreach letter out of prison and have it delivered to Mr. Babington.Unfortunately for Mary, since the government had no trouble interceptingher letters, it could also intercept any lists of random numbers shetried to smuggle out of prison.

Modern electronic communications allows us to send data very rapidlyacross great distances. Such transmission mechanisms over the Internetor otherwise are typically less secure than Mary's letters smuggled inempty ale casks. In fact, modern computer security analysts usually mustassume that any information transmitted between two parties over apublic network will be intercepted and used by an attacker for whateverhe or she may glean from it. While is possible to encrypt secret keyinformation that is used to encrypt the message, this doesn't necessarysolve the problem because it still requires key or other randominformation to be securely shared. Sometimes, people use differentcommunications channels (e.g., mail or hand delivery) to exchange secretkey information. Such exchange techniques are troublesome and costly andmay not be successful since, as Mary learned to her horror, any form ofmessage conveyance (even secret letters smuggled out in ale casks bysupposedly trusted aids) can be intercepted if the stakes are highenough.

There are applications beyond encryption and secure messaging forsecurely sending randomness and/or entropy. For example, widely varyingpurposes including but not limited to science, art, statistics,cryptography, gaming, gambling, and other fields all benefit from theuse of randomness and entropy. Many such applications including computersecurity and beyond could benefit from secure communication andmaintenance of such randomness and entropy. See e.g., E. Barker and J.Kelsey, Recommendation for Random Number Generation Using DeterministicRandom Bit Generators, NIST Special Publication 800-90A, rev. 1, Nat'lInst. of Standards and Technology, June 2015;http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-90Ar1.pdf;N. Heninger et al., “Mining Your Ps and Qs: Detection of Widespread WeakKeys in Network Devices,” Proc. 21st USENIX Security Symp. (Security12), 2012;www.usenix.org/system/files/conference/usenixsexurity12/sec12-final228.pdf;A. Vassilev and T. Hall, “The Importance of Entropy to InformationSecurity,” Computer, vol. 47, no. 2, 2014, pp. 79-81; and Entropy as aService: Unlocking Cryptography's Full Potential (IEEE ComputerSeptember 2016, pp. 98-102, vol. 49).

Thus, while much work has been done in the past, further improvementsare possible and desirable.

BRIEF DESCRIPTION OF THE DRAWINGS

Features and advantages of example non-limiting implementations may beunderstood from the following detailed description of examplenon-limiting embodiments, in conjunction with the drawings of which:

FIG. 1 shows an example non-limiting random information sharing system.

FIG. 1A shows an example entropy sending system,

FIG. 1B shows an example entropy receiving system.

FIG. 2 shows an example non-limiting entropy stream format.

FIG. 2A shows an example non-limiting embedded system message.

FIG. 3 shows an example entropy expansion technique.

FIG. 4 shows an example non-limiting transmission of an entropy stream.

FIG. 5 shows a system that expands the transmitted entropy stream.

DETAILED DESCRIPTION OF NON-LIMITING EMBODIMENTS

Non-limiting features and advantages of example non-limiting embodimentsinclude:

-   -   A stream that in some embodiments can use standard encryption    -   Messages (deterministic) are OTP encrypted in the stream    -   Both sides expand the encryption using byte vectors/arrays of        randomness    -   There is one or plural (e.g., two) random vectors    -   Plural N (where N may be a random number) vectors provides        better obfuscation (it may simply be a second pass)    -   N number vectors have members periodically swapped out.    -   Vector random bytes are hidden in messages; or in other        embodiments, the messages direct which bytes may be swapped out        from the stream of randomness/entropy.    -   In some embodiments, a small stash of randomness is stored        separately and comes in the messages and/or is pulled off the        random/entropy stream as directed by the messages. This has a        separate expansion vector process.    -   Such a separate stash could also come from the expanded entropy        as directed by the messaging.    -   Vectors can start at different points per expansion as directed.    -   Vectors can also be scrambled as directed per pass.

In one example non-limiting implementations, random information istransmitted in unencrypted form over a communications channel. In mostpractical systems, the designers of the system will assume that anattacker will have access to and can eavesdrop upon the random streamtransmission.

In example non-limiting embodiments, a message is embedded within thestream. The messages encrypted using a random one time pad (OTP) looklike part of the random string since the OTP is itself random. Theencrypted message contains information used to identify and/or point torelevant information in another part of the random stream. For example,the OTP-encrypted message may indicate the number of units of themessage, and point to a position in another part of the stream whereanother message is located.

In some example embodiments, the message is also a random string, i.e.,a sequence of random values generated by a random number generator.Using a random One Time Pad to transpose or encrypt a sequence of randomvalues results in a random string that cannot be attacked throughfrequency analysis or any other known cryptanalysis—it is perfectlysecure. In some embodiments, the resulting random string is furtherencrypted using conventional encryption (e.g., AES 256 or any othersymmetrical or asymmetrical encryption) before transmission. If desired,further precautions such as cryptographic key rotation, port rotation,and/or transmission of decoy stream, may be used to further increasesecurity and make the random string inaccessible to an attacker.However, even if the attacker could defeat such additional security toobtain the transmitted random string, the attacker would still not beable to learn the underlying random string message because it has beenencrypted using a perfectly secure One Time Pad.

In some non-limiting embodiments, the amount of transmitted random(entropy) data actually used to enable cryptographic processes can bereduced or minimized, and each (or multiple) ends of a cryptographicprocess can used shared secrets to expand the entropy data as needed.The shared secrets can be transmitted in additionalexpansion-instruction messages embedded within the stream that providevectors for entropy expansion. These expansion-instruction messages canbe entrypted using one time pads that comprise parts of the entropystream or the expanded entropy stream. In some embodiments, theexpansion-instruction messages can be shared at times that are differentfrom when the entropy data is transmitted, using differentcommunications channels. In some embodiments, the expansion-instructionmessages could be shared in a highly secure way such as by courier orpersonal meeting. For example, they could be stored in tamper-resistantdongles or other memory devices that are provided in physical form.

When an attacker intercepts a random stream transmitted over theInternet or other insecure communications channel, he or she will not beable to distinguish the encrypted message from any other part of thestream. Because the message (which may itself be entropy) is encryptedusing a onetime pad, it is perfectly secure. Only if one knows where themessage is embedded and the length and format of the message as well asthe random information used to encrypt the message using the one timepad (which, in a correct implementation is not accessible), is itpossible to decrypt the message in order to learn its contents. In somecases, message contents indicate the other parts of the stream thatcontain particular random data used to encrypt messages to becommunicated, expansion vector information (instructions used to expandthe entropy stream), as well as other housekeeping information such ascheck sums and time stamps. In short, this system uses determinism andrandomness to remove all but the expansion pass(es). For expansion, thevector, provided in the OTP encrypted messages, and the output areknown. Even if we do not encrypt the stream of randomness to beexpanded, the expanded entropy is still unknown. The proof, we know therandom data is 10, is: 10⊗Y=Z. There is no way to discover the values ofY or Z as there is not enough information. This makes discovering theexpanded randomness impossible through mathematical analysis.

In accordance with other non-limiting aspects, the entropy transmissionsystem can “farm” the output of the entropy generator in order toharvest random data for use. In such example non-limitingimplementations, the system may direct the output of an entropygenerator to a buffer in a memory device. The system may harvestselected portions of the buffer, deduplicate them to avoid possibleduplicative information (although this will generally not be necessaryif the entropy is truly random), and transmit the deduplicatedinformation over a communications channel. The harvesting anddeduplication processes are preferably performed in such a way that doesnot decrease the amount of entropy in the information being sent.

Example Entropy Farming System

FIG. 1 shows an example non-limiting entropy transmission system 50including an entropy transmitter 100 and an entropy receiver 200. Withinentropy transmitter 100, an entropy generator (random or pseudorandomnumber generator) 102 generates a stream of random or pseudorandom datavalues. This stream is “farmed” by an entropy farmer 103 and stored inan entropy pool 106. The entropy pool 106 is harvested or reaped by anentropy reaper 108 and formatted into entropy files 250. The files 250are provided to an entropy sender (transmitter) 116 fortransmission/communication to an entropy receiver 202.

The entropy receiver 202 recovers the entropy files 250′ and stores thereceived entropy files in an entropy cache 210 for use in anyapplication where entropy is useful.

FIG. 1A shows an example entropy generator and transmission system 100in the particular context of an encrypted message transmission system.System 100 includes entropy generator 102 that generates random orpseudorandom data with a high degree of entropy, i.e., unpredictability.Such generator 102 can operate on known principles based on for exampleelectrical discharge, temperature fluctuations, quantum physics, etc.The entropy generator output 104 is “farmed” by being selectivelywritten into a memory 106 such as a magnetic disk drive, a semiconductormemory or any other storage device to provide an entropy pool. Anentropy “harvester” or “reaper” 108 reads random or pseudorandom datafrom memory (entropy pool) 106, just as a combine harvests crops from afarmer's field, breaking the data up into files or blocks. The entropydata can be “conditioned” such as (but not limited to) deduplicated by adeduplicator 110 as part of this process to eliminate redundancy (ifnecessary) to provide a random stream of values use such as byencryption performed by encryptor 112. Deduping may also be performedright before expansion. This further hides OTP encrypted messagesembedded in the data stream that will likely contain some duplicates.This further masks the messages in the steam of random information. Tothat point, conditioning/deduplicating can be performed in any order. Afile formatter 114 formats the deduplicated random values into files(which may be of variable length). In some embodiments, files are notdeduplicated until they reach the receiver and/or are expanded at thereceiver (see below).

The system 100 also inserts, preferably at some random position withinthe random file stream, an embedded message encrypted using a One TimePad (OTP).

A transmitter 116 transmits the file stream with embedded message(s)over one or more entropy channel(s). See e.g., U.S. Pat. Nos. 8,995,652and 9,584,313. Port facading and other moving target defense strategiesmay be used to make it more difficult for an attacker to intercept anyuseful portion of the transmitted stream. The same or differenttransmitter 118 may be used to transmit, over the same or differentchannels, ciphertexts of messages the encryptor 112 encrypts.

FIG. 2 shows an example output stream that the FIG. 1A transmit system100 generators. The output stream comprises a plurality of sequentiallytransmitted files 250 embedded in which is an OTP encrypted message 252.Message 252 may comprise a number of fields including for example:

number of files 254

file names 1-N (256(1)-256(N)) corresponding to N files 254

cyclic redundancy check (CRC) values 258—one for each file

pointer 260 to the position of another message in the same or differentfile stream.

a random variable length pad 252 a.

In the embodiment shown in FIG. 2 , the overall transmission stream isnot encrypted but the embedded message portion is encrypted. In otherexample embodiments, some or all of the rest of the transmission streamis also encrypted using conventional encryption such as AES, DES, PublicKey, block cipher chain or any other conventional form of encryption.

FIG. 2A shows another example non-limiting embedded system message. Inexample embodiments, system messages are put at different spots in theOTP stream and are variable in length. The number of OTPs being sent isalso variable to ensure the streams cannot be easily identified. TheSystem Messages are OTP encrypted to ensure they cannot be decrypted byan attacker. They contain deterministic information around portrotation, expansion and other important information required to keep thetwo sides of the OTP transfer in synchronization.

The number of files 254 may be variable and may change randomly witheach transmission. Thus, the number of files needed to cover aparticular cache is a moving target that an attacker will not be able topredict beforehand.

The pointer 260 in some examples could point to the position of the nextmessage 252 in the same file stream. In other implementations, the filestream could be transmitted in any order, and message 252 could point toa previously transmitted part of the file stream as opposed to a part ofthe file stream that already has been transmitted. The system 50preferably locates the initially transmitted message via some conventionthat is not known to or discoverable by an attacker, and that can itselfbe randomized.

The message 252 is padded with a random length data string 252 a ofrandom content. Additional random content may be included in other partsof the stream in some embodiments such as before and/or after the filestream (or in some cases, in between files).

FIG. 1B shows an example non-limiting receiving system 200. Receivingsystem 200 includes a receiver 204 that receives information transmitter118 transmits over message channel(s) 120, and the same or differentreceiver 202 that receives information transmitter 116 transits overentropy channel(s) 117. Receiver 202 provides the received random streamto a deformatter 206 that deformats the transmitted information torecover the original stream and also recovers the embedded formattingmessage (which is recovered using OTP decryption). In the example shown,the deformatter 206 uses information in the recovered message to resolvethe received stream into file structures matching (or at least bearing apredetermined relationship with) the corresponding file structures attransmitter 100. An error corrector 208 uses forward error correctioninformation from the recovered embedded information to correct errors inthe received stream. The output of error corrector 208 may be providedto buffer in a memory (pool) 210, and may also be provided to adecryptor that decrypts the ciphertext received by receiver 204 toprovide clear text.

While transmitter 100 includes an encryptor 112 and transmitter andreceiver 200 includes a receiver 204 and decryptor 212 to conveyencrypted messages securely, other embodiments (such as shown in FIG. 1) need not include such components and may instead use the systemprimarily or exclusively to convey entropy from transmitting system 100to receiving system 200. Alternatively, systems 100, 200 could includeadditional components in addition to those shown that use thecommunicated entropy for any purpose including but not limited toscience, art, statistics, cryptography, gaming, gambling, and otherfields.

The examples shown in FIGS. 1A, 1B can be implemented in any desiredstructure including hardware, software or a combination of hardware andsoftware. For example, in one implementation, one or more hardwareprocessors and/or processors executing software are used to implementthe various blocks of FIGS. 1A, 1B. For example, the steps describedherein can be performed by at least one processor based on instructionsstored in one or more non-transitory memories that the processorexecutes. The channels 117, 120 can be any type of communicationschannels including but not limited to wired or wireless, Internet,cellular telephone, remote or local, and/or sneakernet.

Example Entropy Expansion

As shown in FIG. 1 , system 50 includes further an additional entropyexpansion feature including entropy expanders 300 that developadditional entropy, acting as a sort of an entropy synthesis. FIG. 3shows how an entropy file 250(A) can be expanded into any number N ofentropy files 250(1), . . . , 250(N) comprising new random files290(A.1), . . . 290(A.N). An expansion manifest 302 (see FIG. 1 ) isused for the expansion function. The expansion function in one examplenon-limiting embodiment does not add any additional entropy, but ratherprovides a non-random transformation between the original entropy fileand a number of additional new files 290 which are different from oneanother but still have the same entropy as the original entropy file.Example transformations for the expansion manifest 302 could include forexample XOR, addition, multiplication, or any mathematical and/orlogical transformation. One example is to XOR the file against arandomly-selected vector of files, and discarding the file immediatelyafter a single use. The vector of files can be randomly selected aftereach use. Such expansion not only reduces the amount of information thatneeds to be exchanged, but also means that the new random files actuallyused by an application to provide random values are never themselvestransmitted or otherwise revealed outside of the transmitter 100 andreceiver 200 (each side independently derives them from otherinformation).

If the expansion vector is randomly and deterministically changed, theoverall message does not need to be encrypted before transmission andwill nevertheless remain secure. Security is derived from thedeterministically random expansion vector feature, which has the effectof preventing an attacker from learning the content of the underlying,untransmitted random string. Other embodiments may encrypt some or allof the message using for example standard encryption techniques.

Example Entropy Expansion System

FIGS. 4 and 5 show a further embodiment of an entropy transmission andexpansion system 1000. FIG. 4 shows an example transfer process and FIG.5 shows a transfer and expansion process. The expansion creates an evenmore secure transfer as the raw entropy is not actually what is beingused for encryption. As long as everything on both ends remains secure,there is no way to discover the actual “Pad” used for encryption. Inthis context, True Random data is being referred to as “entropy” andwhat we are OTP encrypting with as a pad in this expansion scenario.Once we process it, it is no longer entropy by strict definition but wecan prove it is still unknown, hence true, random. When true randomnessis used with determinism, we are reaching perfect security when thisexpanded randomness is used for OTP Encryption of data ancillary to thissystem.

In the FIG. 4 example shown, an entropy service 1002 transmits entropyto an entropy client 1004. The entropy service 1002 generates theentropy as discussed above using an RNG, and transmits it over apotentially insecure or open channel such as the Internet. The entropyservice 1002 may transmit the same entropy to multiple entropy clients1004(1), 1004(2), . . . 1004(n) over the same or differentcommunications channels. The entropy client(s) 1004 can use the entropyfor any of a variety of applications including but not limited tocryptographic processes such as encryption and/or authentication. Forexample, the entropy service 1002 may send entropy to two clients1004(1), 1004(2) which will use the (now shared) entropy to encrypt anddecrypt messages the clients exchange among themselves.

In the FIG. 4 example, the entropy stream the service 1002 sends to theclient(s) 1004 is encrypted. Encryption may be performed using aconventional secure encryption method such as AES 256 or any successorsto such encryption standard in common use at the time you are readingthis. See e.g., Federal Information Processing Standards. 26 Nov. 2001doi:10.6028/NIST.FIPS.197.

Additional messages 1006 are embedded in the FIG. 4 stream. Theseadditional messages 1006(1), 1006(2), . . . 1006(n) comprise OTPencrypted messages and hidden entropy. In this non-limiting embodiment,the OTP encrypted messages 1006 include deterministic information aboutport rotation, key changes for the legacy (AES256) encryption, entropyrotation (vectors) for expansion and entropy to be expanded for thesemessages as well as other system information. The configuring ofmessages 1006 follows the rules of the Vernam Cipher so they areperfectly secured messages. All other information in this stream is pureentropy encrypted with any legacy encryption such as AES256. This isalso perfectly secure from brute force discovery as the payload isentropy which is random and unknown.

As shown in FIG. 5 , the entropy client 1004 expands the receivedentropy using the received entropy expansion vectors and a deterministicprocess. These expansion vectors are instructions or “a recipe” forexpanding the received entropy using a deterministic process. Entropyexpansion follows the same basic rules as the One Time Pad. The simpleproof is exactly the same:

X+Y=Z.

As long as two as the variables remain unknown, there is no way to solvefor the problem. In this case, we ensure this by One Time Pad encryptingboth the vector information and the message information to be expanded.As long as the base entropy is true random for all parts, the resultwill be an even distribution of probability that will be unsolvable.

Each message 1006 in this example is OTP encrypted. It contains message(msg) entropy as well replacement entropy for the expansion vector. Italso contains determistic messages around rotation. This ensures thatthe expansion vector, the entropy used to encrypt these messages and anycommand/control data is perfectly secure and remains unknown. It alsoensures that no known data is sent in the raw entropy stream. Commandand control information would be repeatable data that could be used todecrypt the legacy encryption protecting the raw entropy. This leaves noopportunity for brute force cracking of the legacy encryption.

As FIG. 5 shows, the raw base entropy and the message entropy are storedseparately in separate storage/buffer devices 1012, 1014 and used fordifferent purposes. In this example, the expanded message entropy or padis used to decrypt messages 1006 (i.e., as overhead to support system1000), and the expanded base entropy or pad is used by the entropyclient 1004 for the any desired application as discussed above includingbut not limited to one time pad encryption of messages to be exchangedwith one or multiple parties.

A processor, circuit, or other computing device expands each storedentropy by performing an expansion process 1020 using the techniquesdescribed above based on the received expansion vectors. The expansionprocess 1020 for the raw base entropy can but need not be the same asthe expansion process for the message entropy. In the example show, theexpansion process is a simple XOR with additional secret random entropydata shared in messages 1006. Multiple such XOR operations with multiplestreams of additional shared secret entropy data yield any desiredquantity of entropy. The expanded entropy is stored in storage devices1016, 1018 and used as an expanded base entropy or pad and an expandedmessage entropy or pad, respectively.

In some non-limiting embodiments, the messages 1006 provide informationin the way of pointers, indices or other constructs to synchronize orline up the resulting expanded entropy for use. For example, not all ofthe expanded entropy needs to be used—only a subset of the expandedentropy might be used in some embodiments. Additionally, the resultingexpanded entropy can be rotated or substituted as needed with otherexpanded entropy.

All items cited above are hereby incorporated by reference as ifexpressly set forth.

While the invention has been described in connection with what ispresently considered to be the most practical and preferred embodiments,it is to be understood that the invention is not to be limited to thedisclosed embodiments, but on the contrary, is intended to cover variousmodifications and equivalent arrangements included within the spirit andscope of the appended claims.

1. A secure transmission method comprising: embedding a onetime padencrypted message within a random message stream, the onetime padencrypted message comprising at least a pointer within the same ordifferent stream to another one time pad encrypted message; andtransmitting the random message stream including the embedded one timepad encrypted message to at least one receiver.
 2. A secure receivingmethod comprising: receiving a random message stream including anembedded one time pad encrypted message; and decrypting the one time padencrypted message to obtain at least a pointer to another one time padencrypted message within the same or different stream.
 3. A methodcomprising: receiving entropy; receiving at least one message with theentropy, the received message containing an instruction for expandingthe transmitted entropy; recovering the instruction from the messageusing a One Time Pad decryption; and expanding the received entropybased on the instruction using a deterministic process.
 4. The method ofclaim 3 wherein the at least one message is embedded in the receivedentropy.
 5. The method of claim 3 wherein the entropy is transmittedover the Internet.
 6. The method of claim 3 further including generatingthe entropy with a random number generator.